home *** CD-ROM | disk | FTP | other *** search
/ InterCD 2001 May / may_2001.iso / intercd / root / Multimedia / ^DivX_Article / virtualdub / VirtualDub-source-1_4d / Error.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2001-03-20  |  6.2 KB  |  214 lines
  1. //    VirtualDub - Video processing and capture application
  2. //    Copyright (C) 1998-2001 Avery Lee
  3. //
  4. //    This program is free software; you can redistribute it and/or modify
  5. //    it under the terms of the GNU General Public License as published by
  6. //    the Free Software Foundation; either version 2 of the License, or
  7. //    (at your option) any later version.
  8. //
  9. //    This program is distributed in the hope that it will be useful,
  10. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. //    GNU General Public License for more details.
  13. //
  14. //    You should have received a copy of the GNU General Public License
  15. //    along with this program; if not, write to the Free Software
  16. //    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. #include "VirtualDub.h"
  19.  
  20. #include <stdio.h>
  21. #include <stdarg.h>
  22. #include <crtdbg.h>
  23. #include <windows.h>
  24.  
  25. #include "Error.h"
  26.  
  27. MyError::MyError() {
  28.     buf = NULL;
  29. }
  30.  
  31. MyError::MyError(MyError& err) {
  32.     buf = new char[strlen(err.buf)+1];
  33.     if (buf)
  34.         strcpy(buf,err.buf);
  35. }
  36.  
  37. MyError::MyError(const char *f, ...) {
  38.     va_list val;
  39.  
  40.     va_start(val, f);
  41.     vsetf(f, val);
  42.     va_end(val);
  43. }
  44.  
  45. MyError::~MyError() {
  46.     delete[] buf;
  47. }
  48.  
  49. void MyError::setf(const char *f, ...) {
  50.     va_list val;
  51.  
  52.     va_start(val, f);
  53.     vsetf(f,val);
  54.     va_end(val);
  55. }
  56.  
  57. void MyError::vsetf(const char *f, va_list val) {
  58.     buf = new char[1024];
  59.     if (buf) {
  60.         buf[1023] = 0;
  61.         _vsnprintf(buf, 1023, f, val);
  62.     }
  63. }
  64.  
  65. void MyError::post(HWND hWndParent, const char *title) {
  66.     if (!buf || !*buf)
  67.         return;
  68.  
  69.     _RPT2(0,"*** %s: %s\n", title, buf);
  70.     MessageBox(hWndParent, buf, title, MB_OK | MB_ICONERROR);
  71. }
  72.  
  73. void MyError::discard() {
  74.     buf = NULL;
  75. }
  76.  
  77. MyICError::MyICError(const char *s, DWORD icErr) {
  78.     const char *err = "(Unknown)";
  79.  
  80.     switch(icErr) {
  81.     case ICERR_OK:                err = "no error"; break;
  82.     case ICERR_UNSUPPORTED:        err = "unsupported"; break;
  83.     case ICERR_BADFORMAT:        err = "bad format"; break;
  84.     case ICERR_MEMORY:            err = "out of memory"; break;
  85.     case ICERR_INTERNAL:        err = "internal error"; break;
  86.     case ICERR_BADFLAGS:        err = "bad flags"; break;
  87.     case ICERR_BADPARAM:        err = "bad parameters"; break;
  88.     case ICERR_BADSIZE:            err = "bad data size"; break;
  89.     case ICERR_BADHANDLE:        err = "bad handle"; break;
  90.     case ICERR_CANTUPDATE:        err = "can't update"; break;
  91.     case ICERR_ABORT:            err = "aborted by user"; break;
  92.     case ICERR_ERROR:            err = "unspecified error"; break;
  93.     case ICERR_BADBITDEPTH:        err = "can't handle bit depth"; break;
  94.     case ICERR_BADIMAGESIZE:    err = "bad image size"; break;
  95.     default:
  96.         if (icErr <= ICERR_CUSTOM) err = "<custom error>";
  97.         break;
  98.     }
  99.  
  100.     setf("%s error: %s (%ld)", s, err, icErr);
  101. }
  102.  
  103. MyMMIOError::MyMMIOError(const char *s, DWORD mmioerr) {
  104.     const char *err = "(Unknown)";
  105.  
  106.     switch(mmioerr) {
  107.     case MMIOERR_FILENOTFOUND:        err = "file not found"; break;
  108.     case MMIOERR_OUTOFMEMORY:        err = "out of memory"; break;
  109.     case MMIOERR_CANNOTOPEN:        err = "couldn't open"; break;
  110.     case MMIOERR_CANNOTCLOSE:        err = "couldn't close"; break;
  111.     case MMIOERR_CANNOTREAD:        err = "couldn't read"; break;
  112.     case MMIOERR_CANNOTWRITE:        err = "couldn't write"; break;
  113.     case MMIOERR_CANNOTSEEK:        err = "couldn't seek"; break;
  114.     case MMIOERR_CANNOTEXPAND:        err = "couldn't expand"; break;
  115.     case MMIOERR_CHUNKNOTFOUND:        err = "chunk not found"; break;
  116.     case MMIOERR_UNBUFFERED:        err = "unbuffered"; break;
  117.     case MMIOERR_PATHNOTFOUND:        err = "path not found"; break;
  118.     case MMIOERR_ACCESSDENIED:        err = "access denied"; break;
  119.     case MMIOERR_SHARINGVIOLATION:    err = "sharing violation"; break;
  120.     case MMIOERR_NETWORKERROR:        err = "network error"; break;
  121.     case MMIOERR_TOOMANYOPENFILES:    err = "too many open files"; break;
  122.     case MMIOERR_INVALIDFILE:        err = "invalid file"; break;
  123.     }
  124.  
  125.     setf("%s error: %s (%ld)", s, err, mmioerr);
  126. }
  127.  
  128. MyAVIError::MyAVIError(const char *s, DWORD avierr) {
  129.     const char *err = "(Unknown)";
  130.  
  131.     switch(avierr) {
  132.     case AVIERR_UNSUPPORTED:        err = "unsupported"; break;
  133.     case AVIERR_BADFORMAT:            err = "bad format"; break;
  134.     case AVIERR_MEMORY:                err = "out of memory"; break;
  135.     case AVIERR_INTERNAL:            err = "internal error"; break;
  136.     case AVIERR_BADFLAGS:            err = "bad flags"; break;
  137.     case AVIERR_BADPARAM:            err = "bad parameters"; break;
  138.     case AVIERR_BADSIZE:            err = "bad size"; break;
  139.     case AVIERR_BADHANDLE:            err = "bad AVIFile handle"; break;
  140.     case AVIERR_FILEREAD:            err = "file read error"; break;
  141.     case AVIERR_FILEWRITE:            err = "file write error"; break;
  142.     case AVIERR_FILEOPEN:            err = "file open error"; break;
  143.     case AVIERR_COMPRESSOR:            err = "compressor error"; break;
  144.     case AVIERR_NOCOMPRESSOR:        err = "compressor not available"; break;
  145.     case AVIERR_READONLY:            err = "file marked read-only"; break;
  146.     case AVIERR_NODATA:                err = "no data (?)"; break;
  147.     case AVIERR_BUFFERTOOSMALL:        err = "buffer too small"; break;
  148.     case AVIERR_CANTCOMPRESS:        err = "can't compress (?)"; break;
  149.     case AVIERR_USERABORT:            err = "aborted by user"; break;
  150.     case AVIERR_ERROR:                err = "error (?)"; break;
  151.     }
  152.  
  153.     setf("%s error: %s (%08lx)", s, err, avierr);
  154. }
  155.  
  156. MyMemoryError::MyMemoryError() {
  157.     setf("Out of memory");
  158. }
  159.  
  160. MyWin32Error::MyWin32Error(const char *format, DWORD err, ...) {
  161.     char szError[128];
  162.     char szTemp[256];
  163.     va_list val;
  164.  
  165.     FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
  166.             0,
  167.             err,
  168.             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  169.             szError,
  170.             sizeof szError,
  171.             NULL);
  172.  
  173.     if (szError[0]) {
  174.         long l = strlen(szError);
  175.  
  176.         if (l>1 && szError[l-2] == '\r')
  177.             szError[l-2] = 0;
  178.         else if (szError[l-1] == '\n')
  179.             szError[l-1] = 0;
  180.     }
  181.  
  182.     va_start(val, err);
  183.     szTemp[sizeof szTemp-1] = 0;
  184.     _vsnprintf(szTemp, sizeof szTemp, format, val);
  185.     va_end(val);
  186.  
  187.     setf(szTemp, szError);
  188. }
  189.  
  190. MyCrashError::MyCrashError(const char *format, DWORD dwExceptionCode) {
  191.     const char *s = "(Unknown Exception)";
  192.  
  193.     switch(dwExceptionCode) {
  194.     case EXCEPTION_ACCESS_VIOLATION:
  195.         s = "Access Violation";
  196.         break;
  197.     case EXCEPTION_PRIV_INSTRUCTION:
  198.         s = "Privileged Instruction";
  199.         break;
  200.     case EXCEPTION_INT_DIVIDE_BY_ZERO:
  201.         s = "Integer Divide By Zero";
  202.         break;
  203.     case EXCEPTION_BREAKPOINT:
  204.         s = "User Breakpoint";
  205.         break;
  206.     }
  207.  
  208.     setf(format, s);
  209. }
  210.  
  211. MyUserAbortError::MyUserAbortError() {
  212.     buf = strdup("");
  213. }
  214.